home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 1996 September & October / Amiga-CD 1996 #9-10.iso / demos / storm-c / stormwizard / example-source / c-source / simple / lock / lock.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-18  |  3.8 KB  |  144 lines
  1. /* Fenster "locken" (das Fenster wird "gesperrt")
  2.  
  3.    (geschrieben unter StormC V1.1)
  4.  
  5.    $VER:              1.0 (12.06.96)
  6.  
  7.    Autor:             Thomas Mittelsdorf
  8.  
  9.    © 1996 HAAGE & PARTNER Computer GmbH,  All Rights Reserved
  10.  
  11. */
  12.  
  13. #include    <stdio.h>
  14.  
  15. #include    <clib/alib_protos.h>
  16.  
  17. #include    <pragma/asl_lib.h>
  18. #include    <pragma/exec_lib.h>
  19. #include    <pragma/intuition_lib.h>
  20. #include    <pragma/utility_lib.h>
  21. #include    <pragma/wizard_lib.h>
  22.  
  23. #include    <libraries/asl.h>
  24. #include    <libraries/wizard.h>
  25. #include    <intuition/gadgetclass.h>
  26. #include    <intuition/intuition.h>
  27.  
  28. #include    "lock.h"
  29.  
  30. APTR    surface;
  31.  
  32. struct Screen    *screen;
  33.  
  34. APTR    filereq;
  35.  
  36. struct NewWindow *newwin;
  37. struct Window    *window;
  38. struct WizardWindowHandle *winhandle;
  39. struct Gadget *gads[WINDOW_MAIN_GADGETS];
  40.  
  41. void main( void)
  42. {
  43.     BOOL Flag;
  44.  
  45.     struct IntuiMessage *msg;
  46.  
  47.  
  48.     // Erstmal die Oberflächenbeschreibung bereitstellen!
  49.     if ((surface=WZ_OpenSurface("lock.wizard",0L,TAG_DONE)))
  50.     {
  51.  
  52.         // Natürlich brauchen wir auch einen Screen oder?
  53.         if ((screen=LockPubScreen(0L)))
  54.         {
  55.             if ((filereq=AllocAslRequestTags(ASL_FileRequest,ASLFR_Screen,screen,
  56.                                                                         TAG_DONE)))
  57.             {
  58.  
  59.                 // Jetzt holen wir uns ein WindowHandle, mit dem unsere Objekte
  60.                 // durch die wizard.library verwaltet werden.
  61.                 if ((winhandle=WZ_AllocWindowHandle(screen,0L,surface,TAG_DONE)))
  62.                 {
  63.  
  64.                     // Da ein WindowHandle nur Sinn macht, wenn auch die Objekte
  65.                     // darin vorkommen, legen wir diese Objekte jetzt an.
  66.                     if ((newwin=WZ_CreateWindowObj(winhandle,WINDOW_MAIN,WWH_GadgetArray,gads,
  67.                                                                                                 WWH_GadgetArraySize,sizeof(gads),
  68.                                                                                                 TAG_DONE)))
  69.                     {
  70.  
  71.                         // Nachdem das glatt ging, versuchen wir unser
  72.                         // Fenster zu öffnen. Dabei werden alle Objekte installiert.
  73.                         if ((window=WZ_OpenWindow(winhandle,newwin,WA_AutoAdjust,TRUE,
  74.                                                                                 TAG_DONE)))
  75.                         {
  76.                             Flag=TRUE;    // Flag für Beenden der nachfolgenden Schleife
  77.  
  78.                             do
  79.                             {
  80.                                 // Da wir keine Rechenzeit verschwenden wollen, werden wir
  81.                                 // das Program "schlafen" legen, bis eine Nachricht
  82.                                 // eintifft. Für Profis gilt, das auch Wait() verwendet
  83.                                 // werden kann.
  84.                                 WaitPort(window->UserPort);
  85.  
  86.                                 if ((msg=(struct IntuiMessage *)GetMsg(window->UserPort)))
  87.                                 {
  88.                                     // Ha, da ist doch tatsächlich eine Nachricht ange-
  89.                                     // kommen. Na dann gucken wir mal ob Sie auch vom
  90.                                     // richtigen Type ist.
  91.  
  92.                                     switch(msg->Class)
  93.                                     {
  94.                                         case IDCMP_CLOSEWINDOW:
  95.                                             {
  96.                                                 Flag=FALSE;
  97.                                             }
  98.                                             break;
  99.  
  100.                                         case IDCMP_IDCMPUPDATE:
  101.                                             {
  102.                                                 WZ_LockWindow(winhandle);
  103.  
  104.                                                 AslRequest(filereq,TAG_DONE);
  105.  
  106.                                                 WZ_UnlockWindow(winhandle);
  107.                                             }
  108.                                             break;
  109.                                     }
  110.  
  111.                                     // Da wir keine Speicherleichen dulden und
  112.                                     // das Nachrichtensystem nicht durcheinanden bringen
  113.                                     // wollen, teilen wir den Betriebssystem mit, das
  114.                                     // die Nachricht von uns nicht mehr benötigt wird.
  115.                                     ReplyMsg((struct Message *)msg);
  116.                                 }
  117.                             }
  118.                             while (Flag);
  119.  
  120.                             // Fenster schließen
  121.                             WZ_CloseWindow(winhandle);
  122.                         }
  123.                     }
  124.  
  125.                     // In jedem Fall muß ein mit WZ_AllocWindowHandle() angelegter
  126.                     // WindowHandle auch wieder freigegeben werden. Übrigens
  127.                     // kann das Fenster hierbei noch offen sein. Probieren Sie es!
  128.                     WZ_FreeWindowHandle(winhandle);
  129.                 }
  130.  
  131.                 FreeAslRequest(filereq);
  132.             }
  133.  
  134.             // PublicScreen-Benutzerzähler wieder um eins verringern
  135.             UnlockPubScreen(0L,screen);
  136.         }
  137.  
  138.         // Da wir keine Objekte von dieser Surface mehr besitzen und wir diese
  139.         // auch nicht mehr anlegen geben wir sie frei. Übrigens noch
  140.         // nicht freigegebene WindowHandles werden hierbei von der
  141.         // wizard.libarry entfernt (Fenster auch geschlossen).
  142.         WZ_CloseSurface(surface);
  143.     }
  144. }